/**
 * 验证类
 */
package cn.antia.validation;

import java.util.regex.Pattern;
import java.util.*;
/**
 * @author sunkeei
 * @date Dec 25, 2007
 * @time 5:29:54 PM
 */
public class Validation {
	private static String[] SPECIAL_CHAR = new String[]{"-","=","'","\"","&","^","{","}","'","\\","~","|"};
	/**
	 * 数字判断
	 * @param str
	 * @return
	 * --ok--
	 */
	public static boolean isInt(String str) {
		try {
			Integer.parseInt(str);
		} catch (Exception e) {
			return false;
		}
		return true;
	}

	/**
     * 数字判断(可为负数)
     * 　可有两种调用方式：
     * 一个参数：一个字符串，判断是否为数字串
     * 两个参数:第一个为要判断的字符串，第二个为数字的大小限制:可为'-1000'.'10-90','100-','200'等形式
     *
     * @param arguments arguments:一个或者两个字符串
     * @return bool
     * --ok--
     */
    public static boolean judgeDigit(Object... arguments) {
        String digitReg = "-?[0-9]{1,10}";
        String s = (String) arguments[0];
        if (arguments.length == 1) {
            return match(digitReg, s);
        } else if (arguments.length == 2) {
            //通过验证
            if (match(digitReg, s)) {
                String cond = (String) arguments[1];
                String[] conds = cond.split("-");
                if (conds.length == 1) {
                    if (cond.indexOf("-") > -1) {
                        int sint = Integer.parseInt(s);
                        return sint >= Integer.parseInt(conds[0]);
                    } else {
                        return s.equals(conds[0]);
                    }
                } else if (conds.length == 2) {
                    int sint = Integer.parseInt(s);
                    String cond1 = conds[0];
                    String cond2 = conds[1];
                    if (cond1.equals("")) {
                        return sint <= Integer.parseInt(cond2);
                    }
                    return sint >= Integer.parseInt(cond1) && sint <= Integer.parseInt(cond2);
                }
            }
        }
        return false;
    }

    /**
     * 判断标识符或是登录名，以字母开头,可带数字、"_"、"." 的字串
     * 限定最小长度(第二个参数)与最大长度(第三个参数)(默认为2--32位)
     *
     * @param arguments arguments
     * @return bool
     * --ok--
     */
    public static boolean isSignName(Object... arguments) {
        String s = (String) arguments[0];
        if (arguments.length == 1) {
            String patrn = "[a-zA-Z]{1}([a-zA-Z0-9]|[._]){1,31}$";
            System.out.println(patrn);
            return match(patrn, s);
        } else if (arguments.length == 3) {
            if (isDigit((String) arguments[1]) && isDigit((String) arguments[2])) {
                String patrn = "[a-zA-Z]{1}([a-zA-Z0-9]|[._]){" + (Integer.parseInt((String) arguments[1]) - 1) + "," + (Integer.parseInt((String) arguments[2]) - 1) + "}$";
                System.out.println(patrn);
                return match(patrn, s);
            } else {
                System.out.println("Error:the 2nd argument and the 3rd argument must be number.");
                return false;
            }
        } else {
            System.out.println("method invoke error.error arguments number.");
            return false;
        }
    }

    /**
     * 判断是否是真实姓名
     * 英文名可含有字母，'.','_'与空格
     * 双字节名字可另外包含空格
     *
     * @param s string
     * @return bool
     * --ok--
     */
    public static boolean isRealName(String s) {
        String patrn = "([a-zA-Z0-9]|[._ ]){2,64}$";        //英文名
        String p2 = "([^\\x00-\\xff]|[\\s]){2,32}$";        //双字节名
        return match(patrn, s) || match(p2, s);
    }

    /**
     * 电话号码
     * 必须以数字开头，除数字外，可含有"-"
     *
     * @param s str
     * @return bool
     * --ok--
     */
    public static boolean isTel(String s) {
        String patrn = "[+]{0,3}(\\d){1,3}[ ]?([-]?((\\d)|[ ]){1,12})$";
        return match(patrn, s);
    }

    /**
     * 中国大陆地区手机号码
     * 以13或15开头，使用时请根据变化修改
     * 校验普通电话，除数字外，可用"-"或空格分开
     *
     * @param s str
     * @return bool
     * --ok--
     */
    public static boolean isMobilCN(String s) {
        String patrn = "1[3|5]{1}[0-9]{1}[-| ]?\\d{8}$";
        return match(patrn, s);
    }

    /**
     * 中国地区邮编
     *
     * @param s str
     * @return bool
     * --ok--
     */
    public static boolean isPostalCodeCN(String s) {
        String patrn = "[1-9]\\d{5}$";
        return match(patrn, s);
    }

    /**
     * Emai,很完备的EMAIL格式检查，适用于各种场合
     * @param s str
     * @return bool
     * --ok--
     */
    public static boolean isEmail(String s) {
        String patrn = "\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*";
        return match(patrn, s);
    }

    /**
     * URL
     * @param s URL
     * @return bool
     * --ok--
     */
    public static boolean isURL(String s) {
        String patrn = "http:\\/\\/([\\w-]+(\\.[\\w-]+)+(\\/[\\w-   .\\/\\?%&=\u4e00-\u9fa5]*)?)?$";
        return match(patrn, s);
    }

    /**
     * 严格的32位IP检查
     *
     * @param s ip
     * @return bool
     * --ok--
     */
    public static boolean isIP(String s) {
        String patrn = "((1?\\d?\\d|(2([0-4]\\d|5[0-5])))\\.){3}(1?\\d?\\d|(2([0-4]\\d|5[0-5])))$";
        return match(patrn, s);
    }

    /**
     * 身份证号
     * 这里的省与地区码还没有判断
     * 15位
     * @param s 身份证号
     * @return bool
     * --ok--
     */
    public static boolean isIDNumber15(String s) {
        String patrn = "[\\d]{6}((\\d{2}((0[13578]|1[02])(0[1-9]|[12]\\d|3[01])|(0[13456789]|1[012])(0[1-9]|[12]\\d|30)|02(0[1-9]|1\\d|2[0-8])))|([02468][048]|[13579][26])0229)[\\d]{3}$";
        return match(patrn, s);
    }

    /**
     * 身份证号,包括身份证日期判断
     * 这里的省与地区码还没有判断
     * 18位
     * @param s 身份证号
     * @return bool
     * --ok--
     */
    public static boolean isIDNumber18(String s) {
        String patrn = "[\\d]{6}[0-9]{4}(((0[13578]|(10|12))(0[1-9]|[1-2][0-9]|3[0-1]))|(02(0[1-9]|[1-2][0-9]))|((0[469]|11)(0[1-9]|[1-2][0-9]|30)))[\\d]{3}[\\d|x|X]$";
        return match(patrn, s);
    }

    /**
     * @param s 中文
     * @return bool
     * --ok--
     */
    public static boolean isChineseString(String s) {
        String patrn = "[\u4e00-\u9fa5]+$";
        return match(patrn, s);
    }

    /**
     * 双字节
     * @param s 双字节
     * @return bool
     * --ok--
     */
    public static boolean isDoubleByteString(String s) {
        String patrn = "[^x00-xff]+$";
        return match(patrn, s);
    }

    /**
     * 是否包含首尾空格，如果包含，返回TRUE
     * @param s string
     * @return bool
     * --ok--
     */
    public static boolean hasHESpace(String s) {
    	return s.indexOf(" ") == 0 || s.indexOf(" ") == s.length() - 1;
    }

    /**
     * QQ，最大10位，最小5位
     * @param s qq
     * @return bool
     * --ok--
     */
    public static boolean isQQ(String s) {
        String patrn = "[1-9]{1}\\d{4,9}$";
        return match(patrn, s);
    }

    /**
     * 浮点数
     * 如果是一个参数，那么判断是否为浮点数
     * 如果有两个参数，那么将第二个参数作为精度限定参数
     * 如果有四个参数，那么第三个参数为"<"或">"操作符，第四个参数为数值
     * @param arguments arguments
     * @return bool
     * --ok--
     */
    public static boolean judgeFloat(Object... arguments) {
        if (arguments.length == 1) {
            return isFloat((String) arguments[0]);
        } else if (arguments.length == 2) {
            String patrn = "-?\\d+.?\\d{0," + arguments[1] + "}$";
            return match(patrn, arguments[0].toString());
        } else if (arguments.length == 4) {
            String a3 = (String) arguments[2];
            if (a3.equals(">") || a3.equals("<")) {
                if (isFloat((String) arguments[3])) {
                    String patrn = "-?\\d+.?\\d{0," + arguments[1] + "}$";
                    if (match(patrn, arguments[0].toString())) {
                        if (a3.equals("<")) {
                            if (Float.parseFloat((String) arguments[0]) < Float.parseFloat(arguments[3].toString()))
                                return true;
                        } else {
                            if (Float.parseFloat((String) arguments[0]) > Float.parseFloat(arguments[3].toString()))
                                return true;
                        }
                    }
                    return false;
                }
            } else if (isFloat(a3)) {
                String patrn = "-?\\d+.?\\d{0," + arguments[1] + "}$";
                if (match(patrn, arguments[0].toString())) {
                    float f0 = Float.parseFloat(arguments[0].toString());
                    float f3 = Float.parseFloat(arguments[2].toString());
                    float f4 = Float.parseFloat(arguments[3].toString());
                    return f0 >= f3 && f0 <= f4;
                } else {
                    return false;
                }
            } else {
                System.out.println("the 3rd and the 4th arguments are not number.");
                return false;
            }
        }
        return false;
    }

    /**
     * 是否是浮点数
     * @param s float
     * @return bool
     * --ok--
     */
    public static boolean isFloat(String s) {
        String patrn = "-?\\d*.?\\d+$";
        return match(patrn, s);
    }

    /**
     * 是否闰年
     * @param y year
     * @return bool
     * --ok--
     */
    public static boolean isLeapYear(int y) {
        return (y % 4 == 0 && y % 100 != 0) || y % 400 == 0;
    }

    /**
     * 强大的日期验证,月大月小并包含闰年判断
     * yyyy-mm-dd格式或yyyy/mm/dd格式，年用两位表示亦可
     * Regex author:Michael Ash
     * 支持1600年以后
     * @param s date string
     * @return bool
     * --ok--
     */
    public static boolean isDateYMD(String s) {
        String patrn = "(?:(?:(?:(?:(?:1[6-9]|[2-9]\\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00)))(\\/|-|\\.)(?:0?2\\1(?:29)))|(?:(?:(?:1[6-9]|[2-9]\\d)?\\d{2})(\\/|-|\\.)(?:(?:(?:0?[13578]|1[02])\\2(?:31))|(?:(?:0?[1,3-9]|1[0-2])\\2(29|30))|(?:(?:0?[1-9])|(?:1[0-2]))\\2(?:0?[1-9]|1\\d|2[0-8]))))$";
        return match(patrn, s);
    }

    /**
     * 强大的日期验证,月大月小并包含闰年判断
     * dd-mm-yyyy格式或dd/mm/yyyy格式，年用两位表示亦可
     * Regex author:Marco Storti
     * 支持1600年以后
     * @param s date string
     * @return bool
     * --ok--
     */
    public static boolean isDateDMY(String s) {
        String patrn = "(?:(?:31(\\/|-|\\.)(?:0?[13578]|1[02]))\\1|(?:(?:29|30)(\\/|-|\\.)(?:0?[1,3-9]|1[0-2])\\2))(?:(?:1[6-9]|[2-9]\\d)?\\d{2})$|^(?:29(\\/|-|\\.)0?2\\3(?:(?:(?:1[6-9]|[2-9]\\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))$|^(?:0?[1-9]|1\\d|2[0-8])(\\/|-|\\.)(?:(?:0?[1-9])|(?:1[0-2]))\\4(?:(?:1[6-9]|[2-9]\\d)?\\d{2})$";
        return match(patrn, s);
    }

    /**
     * 强大的日期验证,月大月小并包含闰年判断
     * mm-dd-yyyy格式或mm/dd/yyyy格式，年用两位表示亦可
     * Regex author:Michael Ash
     * 支持1600年以后
     * @param s date string
     * @return bool
     * --ok--
     */
    public static boolean isDateMDY(String s) {
        String patrn = "(?:(?:(?:0?[13578]|1[02])(\\/|-|\\.)31)\\1|(?:(?:0?[13-9]|1[0-2])(\\/|-|\\.)(?:29|30)\\2))(?:(?:1[6-9]|[2-9]\\d)?\\d{2})$|^(?:0?2(\\/|-|\\.)29\\3(?:(?:(?:1[6-9]|[2-9]\\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))$|^(?:(?:0?[1-9])|(?:1[0-2]))(\\/|-|\\.)(?:0?[1-9]|1\\d|2[0-8])\\4(?:(?:1[6-9]|[2-9]\\d)?\\d{2})$";
        return match(patrn, s);
    }

    /**
     * 强大的日期验证,月大月小并包含闰年判断
     * 日期时间：M/d/y hh:mm:ss
     * Regex author:Michael Ash
     * 支持1600年以后
     * @param s date string
     * @return bool
     */
    public static boolean isDateTimeMDY(String s) {
        String patrn = "(?=\\d)(?:(?:(?:(?:(?:0?[13578]|1[02])(\\/|-|\\.)31)\\1|(?:(?:0?[1,3-9]|1[0-2])(\\/|-|\\.)(?:29|30)\\2))(?:(?:1[6-9]|[2-9]\\d)?\\d{2})|(?:0?2(\\/|-|\\.)29\\3(?:(?:(?:1[6-9]|[2-9]\\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))|(?:(?:0?[1-9])|(?:1[0-2]))(\\/|-|\\.)(?:0?[1-9]|1\\d|2[0-8])\\4(?:(?:1[6-9]|[2-9]\\d)?\\d{2}))($|\\ (?=\\d)))?(((0?[1-9]|1[012])(:[0-5]\\d){0,2}(\\ [AP]M))|([01]\\d|2[0-3])(:[0-5]\\d){1,2})?$";
        return match(patrn, s);
    }

    /**
     * 强大的日期验证,月大月小并包含闰年判断
     * 日期时间 yyyy/mm/dd hh:mm:ss 或 yyyy-mm-dd hh:mm:ss
     * Date Regex author:Michael Ash
     * Modified by Shaw Sunkee
     * 支持1600年以后
     * @param s date string
     * @return bool
     */
    public static boolean isDateTimeYMD(String s) {
        String patrn = "(?:(?:(?:(?:(?:1[6-9]|[2-9]\\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00)))(\\/|-|\\.)(?:0?2\\1(?:29)))|(?:(?:(?:1[6-9]|[2-9]\\d)?\\d{2})(\\/|-|\\.)(?:(?:(?:0?[13578]|1[02])\\2(?:31))|(?:(?:0?[1,3-9]|1[0-2])\\2(29|30))|(?:(?:0?[1-9])|(?:1[0-2]))\\2(?:0?[1-9]|1\\d|2[0-8]))))[ ]([0-1]?[0-9]|[2][0-3]):([0-5]?[0-9]):([0-5]?[0-9])$";
        return match(patrn, s);
    }

    /**
     * 时间
     * hh:mm:ss 24小时制 0 ~ 23 hour
     * @param s time string
     * @return bool
     */
    public static boolean isTime(String s) {
        String patrn = "([0-1]?[0-9]|[2][0-3]):([0-5]?[0-9]):([0-5]?[0-9])$";
        return match(patrn, s);
    }

    /**
     * 是否包含非特殊字符(正常字符包括字母数字，下划线，和点号，空格，@#$% 和双字节)
     * 若包含，返回 true
     * @param arguments arguments
     * @return bool
     * --ok--
     */
    public static boolean containsSpecialChar(Object... arguments) {
		String str = (String)arguments[0];
		if(arguments.length == 1){
			   return hasContainsSpecialChar(str);
		}else if(arguments.length == 3){
			int minLen = Integer.parseInt((String)arguments[1]);
			int maxLen = Integer.parseInt((String)arguments[1]);
			if(str.length() <= maxLen && str.length() >= minLen){
				return hasContainsSpecialChar(str);
			}else{
				return true;
			}
		}
		return false;
    }
    private static boolean hasContainsSpecialChar(String str){
    	for(int i = 0;i<SPECIAL_CHAR.length;i++){
    		if(str.indexOf(SPECIAL_CHAR[i]) > -1){
    			return true;
    		}
    	}
    	return false;
    }
    /**
     * 判断是否为数字串(可在串前加"-"号，如：-123)
     * 两种调用方式:
     * 1.一个参数，不限制长度
     * 2.三个参数，第二个参数表示允许的最小长度，第三个参数表示允许的最大长度
     * @param arguments arguments
     * @return bool
     */
    public static boolean isDigitString(Object... arguments) {
        return judgePattrnAndLen("-?\\d", arguments);
    }

    /**
     * 字母串
     * 两种调用方式：
     * 一种是一个参数，传入要验证的值
     * 二种是带三个参数，第二和第三个参数分别代表最小长度和最大长度
     * @param arguments arguments
     * @return bool
     */
    public static boolean isLetter(Object... arguments) {
        return judgePattrnAndLen("[A-Za-z]", arguments);
    }

    /**
     * 大写字母
     * 两种调用方式：
     * 一种是一个参数，传入要验证的值
     * 二种是带三个参数，第二和第三个参数分别代表最小长度和最大长度
     * @param arguments arguments
     * @return bool
     */
    public static boolean isUpperLetter(Object... arguments) {
        return judgePattrnAndLen("[A-Z]", arguments);
    }

    /**
     * 小写字母
     * 两种调用方式：
     * 一种是一个参数，传入要验证的值
     * 二种是带三个参数，第二和第三个参数分别代表最小长度和最大长度
     * @param arguments arguments
     * @return bool
     */
    public static boolean isLowerLetter(Object... arguments) {
        return judgePattrnAndLen("[a-z]", arguments);
    }

    /**
     * 数字与字符串
     * @param arguments arguments
     * @return bool
     */
    public static boolean isLetterNumString(Object... arguments) {
        return judgePattrnAndLen("[A-Za-z0-9]", arguments);
    }

    /**
     * 数字，字母，下划线字符串
     * @param arguments arguments
     * @return bool
     */
    public static boolean isLNUString(Object... arguments) {
        return judgePattrnAndLen("\\w", arguments);
    }

    /**
     * macth 为让其它的方法少写一行代码
     *
     * @param reg 与此同时表达式串
     * @param str   string
     * @return  bool
     */
    private static boolean match(String reg, String str) {
        Pattern pattern = Pattern.compile(reg);
        return pattern.matcher(str).matches();
    }

    private static boolean isDigit(String str) {
        String reg = "-?[0-9]{1,10}";
        Pattern pattern = Pattern.compile(reg);
        return pattern.matcher(str).matches();
    }

    /**
     * 传入一个简单的正则式串，要判定的值，传入限定最小长度和最大长度
     * @param arguments arguments
     * @return bool
     */
    private static boolean judgePattrnAndLen(Object... arguments) {
        String pat = arguments[0].toString();
        Object[] as = (Object[]) arguments[1];
        if (as == null || as.length == 0) {
            System.out.println("no arguments.");
            return false;
        } else if (as.length == 1) {
            return match(pat, as[0].toString());
        } else if (as.length == 3) {
            if (isDigit(as[1].toString()) && isDigit(as[2].toString())) {
                String patrn = pat + "{" + as[1] + "," + as[2] + "}";
                return match(patrn, as[0].toString());
            } else {
                System.out.println("error arguments:the 2nd argument and the 3rd argument must be number.");
                return false;
            }
        } else {
            System.out.println("error arguments number");
            return false;
        }
    }


    /**
     * 出现错误返回错误信息
     * 没有错误返回空或空列表
     * @param name      验证的字段名字
     * @param value     值
     * @param limit     限制字符串
     * @return  错误信息列表
     */
    public static List<String> validElement(String name, String value, String limit) {
        value = value.trim();
        List<String> errors = new ArrayList<String>();
        //属性检查
        if (limit == null || limit.trim().length() == 0) return null;
        limit = limit.trim();

        // prepared....
        //错误信息处理完毕
        //拆分limit信息，提取最重要信息之 -- 是否必须与类型
        String vtype = "string";            //值类型
        boolean required = false;    //是否必须
        boolean general = true;        //是否是一般字符串(不允许包含特殊字符)
        String[] lims = limit.split(";");        //限制列表
        for (String lim2 : lims) {
            if (lim2.indexOf(":") > 0) {
                String[] lim = lim2.split(":");
                if (lim[0].equals("type")) {
                    vtype = lim[1];
                } else if (lim[0].equals("required")) {
                    required = lim[1].equals("true");
                } else if (lim[0].equals("general") && lim[1].equals("false")) {
                    general = false;
                }
            } else {
                System.out.println("Element config error!");
                return null;
            }
        }
        //是否为空
        boolean isNull = value.equals("");
        //空判断 -- 如果不允许为空而实际是空，则返回
        if (required && isNull) {
            errors.add(getErrMessage(name, name + " can't be null."));
        } else if (!isNull) {
            //=============================类型检验========================//
            //=============================类型检验========================//
            //检验类型
            //整数
            if (vtype.equals("int"))
                if (!isDigit(value)) {
                    errors.add(getErrMessage(name, name + " must be digit."));
                }
            if (vtype.equals("float"))
                if (!isFloat(value)) {
                    errors.add(getErrMessage(name, name + " must be float."));
                }
            if (vtype.equals("date"))
                if (!isDateYMD(value)) {
                    errors.add(getErrMessage(name, name + " must be date."));
                }
            if (vtype.equals("datetime"))
                if (!isDateTimeYMD(value)) {
                    errors.add(getErrMessage(name, name + " must be datetime."));
                }
            if (vtype.equals("time"))
                if (!isTime(value)) {
                    errors.add(getErrMessage(name, name + " must be time."));
                }
            if (vtype.equals("tel") || vtype.equals("fax"))
                if (!isTel(value)) {
                    errors.add(getErrMessage(name, name + " must be tel or fax number."));
                }
            if (vtype.equals("modilCn"))
                if (!isMobilCN(value)) {
                    errors.add(getErrMessage(name, name + " must be Chinese"));
                }
            if (vtype.equals("ip"))
                if (!isIP(value)) {
                    errors.add(getErrMessage(name, name + " must be IP."));
                }
            if (vtype.equals("url"))
                if (!isURL(value)) {
                    errors.add(getErrMessage(name, name + " must be URL."));
                }
            if (vtype.equals("idCard"))
                if (!(isIDNumber15(value) || isIDNumber18(value))) {
                    errors.add(getErrMessage(name, name + " must be Chinese IDCard number."));
                }
            if (vtype.equals("email"))
                if (!isEmail(value)) {
                    errors.add(getErrMessage(name, name + " must be Email address."));
                }
            if (vtype.equals("signName"))
                if (!isSignName(value)) {
                    errors.add(getErrMessage(name, name + " must be sign name:character,number,underline,point.The first char must be character."));
                }
            if (vtype.equals("name"))
                if (!isRealName(value)) {
                    errors.add(getErrMessage(name, name + " must be real name:Double byte character or single byte character. or space,point."));
                }
            if (vtype.equals("postcodeCn"))
                if (!isPostalCodeCN(value)) {
                    errors.add(getErrMessage(name, name + " must be valid postcode."));
                }
            //=============================类型检验结束========================//
            //============================其它限制检验=======================//
            if (lims != null) {
                for (String lim1 : lims) {
                    String[] lim = lim1.split(":");
                    if (lim.length != 2) {
                        System.out.println("attrribute limit config error.");
                        return errors;
                    }
                    if (lim[0].equals("len")) {    //长度检查，不管是什么类型，配置了长度就检查
                        String lenDesc = lim[1];
                        //alert(lim[1]);
                        if (lenDesc.indexOf("-") > -1) {
                            String[] ls = lenDesc.split("-");
                            if (ls.length == 2) {
                                if (ls[0].equals("")) {
                                    if (value.length() > Integer.parseInt(ls[1])) {
                                        errors.add(getErrMessage(name, name + " can't more than " + ls[1]));
                                    }
                                } else if (ls[1].equals("")) {
                                    if (value.length() < Integer.parseInt(ls[0])) {
                                        errors.add(getErrMessage(name, name + " can't less than " + ls[0]));
                                    }
                                } else
                                if (value.length() < Integer.parseInt(ls[0]) || value.length() > Integer.parseInt(ls[1])) {
                                    errors.add(getErrMessage(name, name + " must between " + ls[0] + " and " + ls[1]));
                                }
                            } else {
                                System.out.println("Element" + name + " config error.");
                                return errors;
                            }
                        } else {
                            if (value.length() != Integer.parseInt(lenDesc)) {
                                errors.add(getErrMessage(name, name + " the length must be " + lenDesc));
                            }
                        }
                        //限定值区间,仅用于int型与float型
                    } else
                    if (lim[0].equals("between") && lim[1].indexOf("-") > -1 && (vtype.equals("float") || vtype.equals("int"))) {
                        String[] ls = lim[1].split("-");
                        float fv = Float.parseFloat(value);
                        //如果没有下限
                        if (ls[0].equals("")) {
                            if (fv > Float.parseFloat(ls[1])) {
                                errors.add(getErrMessage(name, name + " can't more than " + ls[1]));
                            }
                        } else if (ls[1].equals("")) {    //如果没有上限
                            if (fv < Float.parseFloat(ls[0])) {
                                errors.add(getErrMessage(name, name + " can't less than " + ls[0]));
                            }
                        } else {
                            if (fv < Float.parseFloat(ls[0]) || fv > Float.parseFloat(ls[1])) {
                                errors.add(getErrMessage(name, name + " must between " + ls[0] + " and " + ls[1]));
                            }
                        }
                    } else if (lim[0].equals("decLen") && vtype.equals("float")) {    //浮点数精度
                        if ((value.length() - value.indexOf(".")) > Integer.parseInt(lim[1])) {
                            //转换精度
                            double precision = Math.pow(10, Integer.parseInt(lim[1]));
                            double tempvalu = Math.round(Float.parseFloat(value) * precision) / precision;
                            value = tempvalu + "";
                        }
                    }
                }
            }
            //如果不允许特殊字符
            if (general && vtype.equals("string")) {
                if (containsSpecialChar(value)) {
                    errors.add(getErrMessage(name, name + " can't allow contains special character."));
                }
            }
        }
        return errors;
    }
    
    //设置错误信息函数
    private static String getErrMessage(String attr, String errMsg) {
        return (errMsg == null || errMsg.trim().equals("")) ? attr + " input error:" + errMsg : errMsg;
    }
    
    public static void main(String[] args) {
    	List errors = validElement("name", "", "required:true");
    	if(errors != null && errors.size() > 0){
	    	for(int i = 0;i<errors.size();i++){
	    		System.out.println(errors.get(i));
	    	}
    	}else{
    		System.out.println("ok");
    	}
	}
	
}
